home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / Power.p < prev    next >
Text File  |  1996-05-01  |  33KB  |  942 lines
  1. {
  2.      File:        Power.p
  3.  
  4.      Contains:    Power Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT Power;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __POWER__}
  28. {$SETC __POWER__ := 1}
  29.  
  30. {$I+}
  31. {$SETC PowerIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  38. {$IFC UNDEFINED __MIXEDMODE__}
  39. {$I MixedMode.p}
  40. {$ENDC}
  41. {$ENDC}
  42. {$IFC FOR_SYSTEM8_PREEMPTIVE }
  43. {$IFC UNDEFINED __KERNEL__}
  44. {$I Kernel.p}
  45. {$ENDC}
  46. {$IFC UNDEFINED __NAMEREGISTRY__}
  47. {$I NameRegistry.p}
  48. {$ENDC}
  49. {$ENDC}
  50.  
  51. {$PUSH}
  52. {$ALIGN MAC68K}
  53. {$LibExport+}
  54.  
  55. {$IFC FOR_SYSTEM8_PREEMPTIVE }
  56. {
  57. ========================================================================================
  58.  
  59.     The top of this file contains the Power Management interfaces used in Copland.
  60.     
  61.     The pre-Copland interfaces are below right after a large and obnoxious comment.
  62.  
  63. ========================================================================================
  64. }
  65. {
  66. //************************************************************************************
  67.  
  68.     Low level (I/O architecture) interface
  69.     
  70. //************************************************************************************
  71. }
  72. {
  73. //------------------------------------------------------------------------------------
  74.  
  75.     Power Management usage monitoring.
  76.  
  77.     High level families call PMMonitorUsage for each hardware device they maintain.
  78.     Power management will periodically send messages to the family requesting the
  79.     current UsageCount for each device.
  80.     If power management determines that a device is idle it may be taken off-line.
  81.     Prior to doing so power managment will send a message instructing the family to
  82.     prepare for the device being off-line. When the device is reqired again the family
  83.     uses PMPrepareDevice to instruct power management to bring the device back on-line.
  84.  
  85. //------------------------------------------------------------------------------------
  86. }
  87.  
  88. TYPE
  89.     PMUsageCount                        = UInt32;
  90.     PMMonitorRef = ^LONGINT;
  91. FUNCTION PMMonitorUsage(VAR deviceToBeMonitored: RegEntryRef; adminMessageObject: ObjectID; refCon: UNIV Ptr; VAR newRef: PMMonitorRef): OSStatus; C;
  92. FUNCTION PMStopMonitoring(ref: PMMonitorRef): OSStatus; C;
  93. {
  94. //------------------------------------------------------------------------------------
  95.  
  96.     Device Power State Management
  97.     
  98.     If a family maintains a device which is capable of switching between multiple
  99.     power states, the family should inform power management of the device's
  100.     capabilities and wait for messages directing it to change the device's power
  101.     state.
  102.  
  103. //------------------------------------------------------------------------------------
  104. }
  105.  
  106. CONST
  107.     kPMDeviceDescriptionInitialVersion = 1;
  108.  
  109.  
  110. TYPE
  111.     PMDeviceStateID                        = OSType;
  112.     PMDeviceStateFlags                    = UInt32;
  113.  
  114. CONST
  115.     kPMDevicePoweredMask        = $0001;                        {  device powered vs. not  }
  116.     kPMDeviceConfiguredMask        = $0002;                        {  internal configuration retained vs. not  }
  117.     kPMDeviceUsableMask            = $0004;                        {  "on-line" vs "off-line" (usable or not)  }
  118.     kPMDevicePowerLowestMask    = $0100;                        {  set for device's highest state  }
  119.     kPMDevicePowerHighestMask    = $0200;                        {  set for device's lowest state  }
  120.  
  121.  
  122. TYPE
  123.     PMDeviceStatePtr = ^PMDeviceState;
  124.     PMDeviceState = RECORD
  125.         id:                        PMDeviceStateID;                        {  state identifier - not interpreted by power management  }
  126.         relativeConsumption:    UInt32;                                    {  relative ranking of power consumption  }
  127.         flags:                    PMDeviceStateFlags;                        {  one or more of the bits defined above  }
  128.     END;
  129.  
  130.     PMDeviceDescriptionHdrPtr = ^PMDeviceDescriptionHdr;
  131.     PMDeviceDescriptionHdr = RECORD
  132.         version:                UInt32;
  133.         numberOfStates:            UInt32;
  134.     END;
  135.  
  136.     PMDeviceDescriptionPtr = ^PMDeviceDescription;
  137.     PMDeviceDescription = RECORD
  138.         header:                    PMDeviceDescriptionHdr;
  139.         states:                    ARRAY [0..1] OF PMDeviceState;
  140.     END;
  141.  
  142.     PMManageRef = ^LONGINT;
  143. FUNCTION PMManageDeviceState(VAR deviceToBeManaged: RegEntryRef; adminMessageObject: ObjectID; VAR deviceStates: PMDeviceDescription; descriptionSize: ByteCount; currentState: PMDeviceStateID; refCon: UNIV Ptr; VAR newRef: PMManageRef): OSStatus; C;
  144. FUNCTION PMNewDeviceState(manageRef: PMManageRef; VAR newStates: PMDeviceDescription; stateSize: ByteCount; currentState: PMDeviceStateID): OSStatus; C;
  145. FUNCTION PMStopManaging(ref: PMManageRef): OSStatus; C;
  146. {
  147. //------------------------------------------------------------------------------------
  148.  
  149.     Power Management notification.
  150.     
  151.     Any entity in the I/O architecture can use these routines to be notified about
  152.     changes to device.
  153.     
  154.     Clients use a mask to specify which device aspects they are interested in and
  155.     also to specify when to be notified. Flags describing the new state are generated
  156.     and delivered with the notification.
  157.     
  158.     If the client is interested in power being removed and re-applied, they can request
  159.     it with (kPMNotifyAlwaysMask | kPMNotifyPowerMask). When the notification is 
  160.     delivered the client can check the new flags against kPMNotifyBeforeMask and
  161.     kPMNotifyAfterMask to determine if the change has already occured or not. And can
  162.     check against kPMDevicePoweredMask to determine if the device will have power or
  163.     not in the new state.
  164.     
  165. //------------------------------------------------------------------------------------
  166. }
  167.  
  168. TYPE
  169.     PMNotifyFlags                        = UInt32;
  170.  
  171. CONST
  172.     kPMNotifyPowerMask            = $00000001;
  173.     kPMNotifyConfigurationMask    = $00000002;
  174.     kPMNotifyUsabilityMask        = $00000004;
  175.     kPMNotifyAllMask            = $00000007;
  176.     kPMNotifyBeforeMask            = $40000000;                    {  notification sent before change  }
  177.     kPMNotifyAfterMask            = $80000000;                    {  notification sent after change  }
  178.     kPMNotifyAlwaysMask            = $C0000000;                    {  notification sent before and after  }
  179.  
  180.  
  181. TYPE
  182.     PMNotifyRef = ^LONGINT;
  183. FUNCTION PMNotifyStateChange(VAR interestingDevice: RegEntryRef; adminMessageObject: ObjectID; notifyFlags: PMNotifyFlags; refCon: UNIV Ptr; VAR newRef: PMNotifyRef): OSStatus; C;
  184. FUNCTION PMStopNotification(ref: PMNotifyRef): OSStatus; C;
  185. {
  186. //------------------------------------------------------------------------------------
  187.  
  188.     Power Management message
  189.     
  190.     This structure is used for all types of power management communication - usage
  191.     monitoring, state change notification, and state change commands.
  192.  
  193. //------------------------------------------------------------------------------------
  194. }
  195.  
  196. CONST
  197.     kPMRetrieveUsageCountMessage = 1;
  198.     kPMChangeDeviceStateMessage    = 2;
  199.     kPMNotifyStateChangeMessage    = 3;
  200.  
  201.  
  202. TYPE
  203.     PMMessageDataPtr = ^PMMessageData;
  204.     PMMessageData = RECORD
  205.         CASE INTEGER OF
  206.         0: (
  207.             newStateFlags:        PMNotifyFlags;                            {  used in kPMNotifyStateChangeMessage  }
  208.             );
  209.         1: (
  210.             targetState:        PMDeviceStateID;                        {  used in kChangeDeviceStateMessage  }
  211.             );
  212.     END;
  213.  
  214.     PMMessagePtr = ^PMMessage;
  215.     PMMessage = RECORD
  216.         ampReserved:            UInt32;                                    {  reserved for use by AdminMessagePort service  }
  217.         messageCode:            UInt32;                                    {  one of the message codes above  }
  218.         refCon:                    Ptr;                                    {   }
  219.         data:                    PMMessageData;                            {  message-specific extra data  }
  220.     END;
  221.  
  222. {
  223. //------------------------------------------------------------------------------------
  224.  
  225.     Restoring an off-line or powered off device to a usable state.
  226.     
  227.     When a device that has been taken off-line or has had its power removed is needed
  228.     again, the following routine should be called. This routine will return when after
  229.     the device has been restored (or has failed to be restored). Part of the restoration
  230.     process is delivering notifications to interested parties - kPMPowerRestore and/or
  231.     kPMPrepareOnLine messages will be delivered and processed before this routine 
  232.     returns.
  233.  
  234. //------------------------------------------------------------------------------------
  235. }
  236. FUNCTION PMMakeDeviceUsable(VAR whichDevice: RegEntryRef): OSStatus; C;
  237. {
  238. //------------------------------------------------------------------------------------
  239.  
  240.     Disabling & Re-Enabling power managment of a device.
  241.     
  242.     Power management of a specific device can be disabled - this may be desirable
  243.     because of a resource reservation on some device. 
  244.     Families can implement a family specific API on top of this that can allow
  245.     an application to turn off power management for a particular volume or display
  246.     device.
  247.     
  248.     When power management of some device is disabled usage monitoring will still
  249.     occur, but there will not be any requests to change the device state. The
  250.     domain of which the device is a member will not be changed either.
  251.  
  252. //------------------------------------------------------------------------------------
  253. }
  254. FUNCTION PMDisablePowerManagement(VAR whichDevice: RegEntryRef): OSStatus; C;
  255. FUNCTION PMEnablePowerManagement(VAR whichDevice: RegEntryRef): OSStatus; C;
  256. {
  257. //************************************************************************************
  258.  
  259.     Domain Controller Power Management Plug-In interface.
  260.  
  261. //************************************************************************************
  262. }
  263. {
  264. //------------------------------------------------------------------------------------
  265.  
  266.     Domain description
  267.  
  268. //------------------------------------------------------------------------------------
  269. }
  270.  
  271. CONST
  272.     kPMDomainDescriptionInitialVersion = 1;
  273.  
  274.  
  275. TYPE
  276.     PMDomainID                            = OSType;
  277.     PMDomainLevelID                        = OSType;
  278.     PMDomainLevelFlags                    = UInt32;
  279.  
  280. CONST
  281.     kPMDomainOffMask            = $0000;
  282.     kPMDomainFreezeMask            = $0003;
  283.     kPMDomainReducedMask        = $0007;
  284.     kPMDomainFullMask            = $0207;
  285.  
  286.  
  287. TYPE
  288.     PMDomainLevelPtr = ^PMDomainLevel;
  289.     PMDomainLevel = RECORD
  290.         levelID:                PMDomainLevelID;
  291.         flags:                    PMDomainLevelFlags;
  292.     END;
  293.  
  294.     PMDomainDescriptionHdrPtr = ^PMDomainDescriptionHdr;
  295.     PMDomainDescriptionHdr = RECORD
  296.         descriptionVersion:        UInt32;
  297.         domainID:                PMDomainID;
  298.         numberOfLevels:            UInt32;
  299.     END;
  300.  
  301.     PMDomainDescriptionPtr = ^PMDomainDescription;
  302.     PMDomainDescription = RECORD
  303.         header:                    PMDomainDescriptionHdr;
  304.         levels:                    ARRAY [0..1] OF PMDomainLevel;
  305.     END;
  306.  
  307. {
  308. //------------------------------------------------------------------------------------
  309.  
  310.     Domain plugin. 
  311.     Plugin init routine returns pointer to a domain description as an out parameter.
  312.  
  313. //------------------------------------------------------------------------------------
  314. }
  315.  
  316. CONST
  317.     kPMDomainPluginVersion        = $01000000;
  318.  
  319.  
  320. TYPE
  321.     PMDomainPluginInitProc = ProcPtr;  { FUNCTION PMDomainPluginInitProc(VAR domain: PMDomainDescriptionPtr; VAR numberOfDomains: UInt32): OSStatus; C; }
  322.  
  323.     PMDomainPluginSetLevelProc = ProcPtr;  { FUNCTION PMDomainPluginSetLevelProc(domainID: PMDomainID; levelID: PMDomainLevelID): OSStatus; C; }
  324.  
  325.     PMDomainPluginDispatchTablePtr = ^PMDomainPluginDispatchTable;
  326.     PMDomainPluginDispatchTable = RECORD
  327.         version:                UInt32;
  328.         reserved:                ARRAY [0..2] OF UInt32;
  329.         init:                    PMDomainPluginInitProc;
  330.         setLevel:                PMDomainPluginSetLevelProc;
  331.     END;
  332.  
  333. {
  334. //************************************************************************************
  335.  
  336.     Platform plugin.
  337.     
  338. //************************************************************************************
  339. }
  340.  
  341. CONST
  342.     kPMPlatformPluginVersion    = $01000000;
  343.  
  344.  
  345. TYPE
  346.     PMSleepProc = ProcPtr;  { FUNCTION PMSleepProc(VAR services: OSType; numberOfServices: UInt32): OSStatus; C; }
  347.  
  348.     PMHibernateProc = ProcPtr;  { FUNCTION PMHibernateProc(VAR services: OSType; numberOfServices: UInt32): OSStatus; C; }
  349.  
  350.     PMShutdownProc = ProcPtr;  { FUNCTION PMShutdownProc(VAR services: OSType; numberOfServices: UInt32): OSStatus; C; }
  351.  
  352.     PMRestartProc = ProcPtr;  { FUNCTION PMRestartProc(VAR services: OSType; numberOfServices: UInt32): OSStatus; C; }
  353.  
  354.     PMPlatformPluginPtr = ^PMPlatformPlugin;
  355.     PMPlatformPlugin = RECORD
  356.         version:                UInt32;
  357.         reserved:                ARRAY [0..2] OF UInt32;
  358.         sleep:                    PMSleepProc;
  359.         hibernate:                PMHibernateProc;
  360.         shutdown:                PMShutdownProc;
  361.         restart:                PMRestartProc;
  362.     END;
  363.  
  364. {
  365. //************************************************************************************
  366.  
  367.     High level (application) interface.
  368.     
  369. //************************************************************************************
  370. }
  371. {
  372.     Disk timer: the time a disk must be idle before it is spun down (or other
  373.     power management actions are taken). Applies to all disks, but each disk
  374.     has its own timer (one can stay spun up while the others are spun down).
  375.     
  376.     The minimum will be enforced.
  377.     
  378.     These API control system-wide parameters for the power management of disk devices.
  379.     For control over a specific disk see the <Block Storage or File System> API.
  380.     
  381.     
  382. }
  383.  
  384. CONST
  385.     kPMDiskSpinDownDisabled        = 0;
  386.  
  387. FUNCTION PMSetDiskSpinDownTimeout(seconds: UInt32): OSStatus; C;
  388. FUNCTION PMGetDiskSpinDownTimeout: UInt32; C;
  389. FUNCTION PMGetMinimumDiskSpinDownTimeout: UInt32; C;
  390. {
  391.     Display timer: the period of time in which there has been no user input
  392.     before a display is dimmed or turned off. Applies to all displays, but
  393.     each display has its own timer.
  394.     
  395.     The minimum will be enforced.
  396. }
  397.  
  398. CONST
  399.     kPMDisplayDimmingDisabled    = 0;
  400.  
  401. FUNCTION PMSetDisplayDimmingTimeout(seconds: UInt32): OSStatus; C;
  402. FUNCTION PMGetDisplayDimmingTimeout: UInt32; C;
  403. FUNCTION PMGetMinimumDisplayDimmingTimeout: UInt32; C;
  404. {
  405.     Idle state timer: the period of time in which all devices must be idle 
  406.     before the system is [?]. Basically, this is the timer for whatever action 
  407.     the user chose to happen when the system is idle. Could be sleep, hibernate,
  408.     or shutdown. If the user has explicitly disabled any action the    routines 
  409.     return an error.
  410.     
  411.     The minimum will be enforced and will be greater than or equal to the
  412.     maximum of disk spin down and display dimming times.
  413. }
  414.  
  415. CONST
  416.     kPMIdleStateDisabled        = 0;
  417.  
  418. FUNCTION PMSetIdleStateTimeout(seconds: UInt32): OSStatus; C;
  419. FUNCTION PMGetIdleStateTimeout: UInt32; C;
  420. FUNCTION PMGetMinimumIdleStateTimeout: UInt32; C;
  421. {
  422.     Idle state: routines to get and set the action to be taken when power
  423.     management has determined that the system is idle.
  424.         Disabled: nothing happens when the machine is idle
  425.         Sleep is a soft definition - depends on the hardware: differs 
  426.         between portable and desktop systems.
  427.         Hibernate: save everthing and shutdown, on boot reload the saved
  428.         state.
  429.         Shutdown: just shutdown, nothing restored on boot.
  430. }
  431.  
  432. CONST
  433.     kPMIdleStateKindShutdown    = 1;
  434.     kPMIdleStateKindHibernate    = 2;
  435.     kPMIdleStateKindSleep        = 3;
  436.  
  437. FUNCTION PMSetIdleStateKind(idleStateKind: UInt32): OSStatus; C;
  438. FUNCTION PMGetIdleStateKind: UInt32; C;
  439. {
  440.     Misc. timers: These allow for programmable shutdown and power on. These are 
  441.     real absolute times - turn off at 6:00pm Jan 12 and back on at 8:00am Feb 1. 
  442.     The 'DateAndTimeSpec' is a made-up placeholder.
  443.     
  444.     Shutdown is a real shutdown.
  445.     IdleAction puts the machine into the chosen idle state - if the machine is
  446.     shutdown at the that time nothing happens.
  447.     PowerOn is either a normal boot or a return-from-idle depending on whether
  448.     the system is shutdown or is in its idle state.
  449. }
  450. FUNCTION PMSetShutdownTime(when: ConstTimeObjectPtr): OSStatus; C;
  451. FUNCTION PMGetShutdownTime(when: TimeObjectPtr): OSStatus; C;
  452. FUNCTION PMSetIdleStateTime(when: ConstTimeObjectPtr): OSStatus; C;
  453. FUNCTION PMGetIdleStateTime(when: TimeObjectPtr): OSStatus; C;
  454. FUNCTION PMSetPowerOnTime(when: ConstTimeObjectPtr): OSStatus; C;
  455. FUNCTION PMGetPowerOnTime(when: TimeObjectPtr): OSStatus; C;
  456. {     Immediate control over system state }
  457. FUNCTION PMRestart: OSStatus; C;
  458. FUNCTION PMEnterIdleState(idleStateKind: UInt32): OSStatus; C;
  459. {
  460. //------------------------------------------------------------------------------------
  461.  
  462.     Other high level API.
  463.     
  464.     Other families may want to implement their own power management API that is built
  465.     on top of the API presented here. Examples are the ability to turn off power
  466.     management of a specific storage volume or a specific graphics display. The battery
  467.     family will want/need to export a high level API that can show battery state.
  468.  
  469. //------------------------------------------------------------------------------------
  470. }
  471. {
  472. //************************************************************************************
  473.  
  474.     User activity monitoring.
  475.     
  476.     These routine are used by software that is interested in the lack of and resumption
  477.     of user activity. The usage model is as follows: software requests to be notified
  478.     when all user activity has ceased for a specified amount of time. Once that
  479.     notification has been delivered any user activity will cause the second notification
  480.     to be delivered immediately. After delivery of the resume notification, the reference
  481.     is invalid and software must request notification again if it so desires.
  482.     
  483. //************************************************************************************
  484. }
  485.  
  486. TYPE
  487.     PMUserMonitorRef = ^LONGINT;
  488. FUNCTION PMMonitorUserActivity(minutesIdle: UInt32; VAR howToNotifyIdle: KernelNotification; VAR howToNotifyResume: KernelNotification; VAR newRef: PMUserMonitorRef): OSStatus; C;
  489. FUNCTION PMCancelMonitoring(refToCancel: PMUserMonitorRef): OSStatus; C;
  490. {$ENDC}
  491. {
  492. **************************************************************************************
  493.  
  494.  
  495.     Everything below this comment is the System 7.x Power Manager
  496.     
  497.     This comment is really large and obnoxious so that the separation can be easily
  498.     found when scrolling through the file.
  499.  
  500.  
  501. **************************************************************************************
  502. }
  503. {$IFC FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED }
  504.  
  505. CONST
  506.                                                                 {  Bit positions for ModemByte  }
  507.     modemOnBit                    = 0;
  508.     ringWakeUpBit                = 2;
  509.     modemInstalledBit            = 3;
  510.     ringDetectBit                = 4;
  511.     modemOnHookBit                = 5;                            {  masks for ModemByte  }
  512.     modemOnMask                    = $01;
  513.     ringWakeUpMask                = $04;
  514.     modemInstalledMask            = $08;
  515.     ringDetectMask                = $10;
  516.     modemOnHookMask                = $20;                            {  bit positions for BatteryByte  }
  517.     chargerConnBit                = 0;
  518.     hiChargeBit                    = 1;
  519.     chargeOverFlowBit            = 2;
  520.     batteryDeadBit                = 3;
  521.     batteryLowBit                = 4;
  522.     connChangedBit                = 5;                            {  masks for BatteryByte  }
  523.     chargerConnMask                = $01;
  524.     hiChargeMask                = $02;
  525.     chargeOverFlowMask            = $04;
  526.     batteryDeadMask                = $08;
  527.     batteryLowMask                = $10;
  528.     connChangedMask                = $20;
  529.  
  530.                                                                 {  commands to SleepQRec sleepQProc  }
  531.     sleepRequest                = 1;
  532.     sleepDemand                    = 2;
  533.     sleepWakeUp                    = 3;
  534.     sleepRevoke                    = 4;
  535.     sleepUnlock                    = 4;
  536.     sleepDeny                    = 5;
  537.     sleepNow                    = 6;
  538.     dozeDemand                    = 7;
  539.     dozeWakeUp                    = 8;
  540.     dozeRequest                    = 9;                            {  SleepQRec.sleepQFlags  }
  541.     noCalls                        = 1;
  542.     noRequest                    = 2;
  543.     slpQType                    = 16;
  544.     sleepQType                    = 16;
  545.  
  546. {  bits in bitfield returned by PMFeatures  }
  547.     hasWakeupTimer                = 0;                            {  1=wakeup timer is supported                         }
  548.     hasSharedModemPort            = 1;                            {  1=modem port shared by SCC and internal modem     }
  549.     hasProcessorCycling            = 2;                            {  1=processor cycling is supported                     }
  550.     mustProcessorCycle            = 3;                            {  1=processor cycling should not be turned off         }
  551.     hasReducedSpeed                = 4;                            {  1=processor can be started up at reduced speed     }
  552.     dynamicSpeedChange            = 5;                            {  1=processor speed can be switched dynamically     }
  553.     hasSCSIDiskMode                = 6;                            {  1=SCSI Disk Mode is supported                     }
  554.     canGetBatteryTime            = 7;                            {  1=battery time can be calculated                     }
  555.     canWakeupOnRing                = 8;                            {  1=can wakeup when the modem detects a ring         }
  556.     hasDimmingSupport            = 9;                            {  1=has dimming support built in                     }
  557.     hasStartupTimer                = 10;                            {  1=startup timer is supported                         }
  558.  
  559. {  bits in bitfield returned by GetIntModemInfo and set by SetIntModemState  }
  560.     hasInternalModem            = 0;                            {  1=internal modem installed                         }
  561.     intModemRingDetect            = 1;                            {  1=internal modem has detected a ring                 }
  562.     intModemOffHook                = 2;                            {  1=internal modem is off hook                         }
  563.     intModemRingWakeEnb            = 3;                            {  1=wakeup on ring is enabled                         }
  564.     extModemSelected            = 4;                            {  1=external modem selected                         }
  565.     modemSetBit                    = 15;                            {  1=set bit, 0=clear bit (SetIntModemState)         }
  566.  
  567. {  bits in BatteryInfo.flags                                      }
  568. {  ("chargerConnected" doesn't mean the charger is plugged in)     }
  569.     batteryInstalled            = 7;                            {  1=battery is currently connected                     }
  570.     batteryCharging                = 6;                            {  1=battery is being charged                         }
  571.     chargerConnected            = 5;                            {  1=charger is connected to the PowerBook             }
  572.  
  573.     HDPwrQType                    = $4844;                        {  'HD' hard disk spindown queue element type             }
  574.     PMgrStateQType                = $504D;                        {  'PM' Power Manager state queue element type             }
  575.  
  576. {  client notification bits in PMgrQueueElement.pmNotifyBits  }
  577.     pmSleepTimeoutChanged        = 0;
  578.     pmSleepEnableChanged        = 1;
  579.     pmHardDiskTimeoutChanged    = 2;
  580.     pmHardDiskSpindownChanged    = 3;
  581.     pmDimmingTimeoutChanged        = 4;
  582.     pmDimmingEnableChanged        = 5;
  583.     pmDiskModeAddressChanged    = 6;
  584.     pmProcessorCyclingChanged    = 7;
  585.     pmProcessorSpeedChanged        = 8;
  586.     pmWakeupTimerChanged        = 9;
  587.     pmStartupTimerChanged        = 10;
  588.     pmHardDiskPowerRemovedbyUser = 11;
  589.  
  590. {  System Activity Selectors  }
  591.     OverallAct                    = 0;                            {  general type of activity                             }
  592.     UsrActivity                    = 1;                            {  user specific type of activity                     }
  593.     NetActivity                    = 2;                            {  network specific activity                         }
  594.     HDActivity                    = 3;                            {  Hard Drive activity                                 }
  595.  
  596. {  Storage Media sleep mode defines  }
  597.     kMediaModeOn                = 0;                            {  Media active (Drive spinning and at full power)     }
  598.     kMediaModeStandBy            = 1;                            {  Media standby (not implemented)     }
  599.     kMediaModeSuspend            = 2;                            {  Media Idle (not implemented)     }
  600.     kMediaModeOff                = 3;                            {  Media Sleep (Drive not spinning and at min power, max recovery time)     }
  601.  
  602.     kMediaPowerCSCode            = 70;
  603.  
  604.  
  605. TYPE
  606.     ActivityInfoPtr = ^ActivityInfo;
  607.     ActivityInfo = RECORD
  608.         ActivityType:            INTEGER;                                {  Type of activity to be fetched.  Same as UpdateSystemActivity Selectors  }
  609.         ActivityTime:            LONGINT;                                {  Time of last activity (in ticks) of specified type.  }
  610.     END;
  611.  
  612. {  information returned by GetScaledBatteryInfo  }
  613.     BatteryInfoPtr = ^BatteryInfo;
  614.     BatteryInfo = PACKED RECORD
  615.         flags:                    UInt8;                                    {  misc flags (see below)                             }
  616.         warningLevel:            UInt8;                                    {  scaled warning level (0-255)                         }
  617.         reserved:                UInt8;                                    {  reserved for internal use                         }
  618.         batteryLevel:            UInt8;                                    {  scaled battery level (0-255)                         }
  619.     END;
  620.  
  621.     ModemByte                            = SInt8;
  622.     BatteryByte                            = SInt8;
  623.     PMResultCode                        = LONGINT;
  624.     SleepQRecPtr = ^SleepQRec;
  625.     HDQueueElementPtr = ^HDQueueElement;
  626.     PMgrQueueElementPtr = ^PMgrQueueElement;
  627.     SleepQProcPtr = Register68kProcPtr;  { FUNCTION SleepQ(message: LONGINT; qRecPtr: SleepQRecPtr): LONGINT; }
  628.  
  629.     HDSpindownProcPtr = ProcPtr;  { PROCEDURE HDSpindown(VAR theElement: HDQueueElement); }
  630.  
  631.     PMgrStateChangeProcPtr = ProcPtr;  { PROCEDURE PMgrStateChange(VAR theElement: PMgrQueueElement; stateBits: LONGINT); }
  632.  
  633.     SleepQUPP = UniversalProcPtr;
  634.     HDSpindownUPP = UniversalProcPtr;
  635.     PMgrStateChangeUPP = UniversalProcPtr;
  636.     SleepQRec = RECORD
  637.         sleepQLink:                SleepQRecPtr;                            {  pointer to next queue element                 }
  638.         sleepQType:                INTEGER;                                {  queue element type (must be SleepQType)         }
  639.         sleepQProc:                SleepQUPP;                                {  pointer to sleep universal proc ptr             }
  640.         sleepQFlags:            INTEGER;                                {  flags                                         }
  641.     END;
  642.  
  643.     HDQueueElement = RECORD
  644.         hdQLink:                HDQueueElementPtr;                        {  pointer to next queue element                 }
  645.         hdQType:                INTEGER;                                {  queue element type (must be HDPwrQType)         }
  646.         hdFlags:                INTEGER;                                {  miscellaneous flags                             }
  647.         hdProc:                    HDSpindownUPP;                            {  pointer to routine to call                     }
  648.         hdUser:                    LONGINT;                                {  user-defined (variable storage, etc.)         }
  649.     END;
  650.  
  651.     PMgrQueueElement = RECORD
  652.         pmQLink:                PMgrQueueElementPtr;                    {  pointer to next queue element                 }
  653.         pmQType:                INTEGER;                                {  queue element type (must be PMgrStateQType)     }
  654.         pmFlags:                INTEGER;                                {  miscellaneous flags                             }
  655.         pmNotifyBits:            LONGINT;                                {  bitmap of which changes to be notified for     }
  656.         pmProc:                    PMgrStateChangeUPP;                        {  pointer to routine to call                     }
  657.         pmUser:                    LONGINT;                                {  user-defined (variable storage, etc.)         }
  658.     END;
  659.  
  660.     BatteryTimeRecPtr = ^BatteryTimeRec;
  661.     BatteryTimeRec = RECORD
  662.         expectedBatteryTime:    LONGINT;                                {  estimated battery time remaining (seconds)     }
  663.         minimumBatteryTime:        LONGINT;                                {  minimum battery time remaining (seconds)         }
  664.         maximumBatteryTime:        LONGINT;                                {  maximum battery time remaining (seconds)         }
  665.         timeUntilCharged:        LONGINT;                                {  time until battery is fully charged (seconds) }
  666.     END;
  667.  
  668.     WakeupTimePtr = ^WakeupTime;
  669.     WakeupTime = RECORD
  670.         wakeTime:                LONGINT;                                {  wakeup time (same format as current time)         }
  671.         wakeEnabled:            BOOLEAN;                                {  1=enable wakeup timer, 0=disable wakeup timer     }
  672.         filler:                    SInt8;
  673.     END;
  674.  
  675.     StartupTimePtr = ^StartupTime;
  676.     StartupTime = RECORD
  677.         startTime:                LONGINT;                                {  startup time (same format as current time)         }
  678.         startEnabled:            BOOLEAN;                                {  1=enable startup timer, 0=disable startup timer     }
  679.         filler:                    SInt8;
  680.     END;
  681.  
  682. FUNCTION DisableWUTime: OSErr;
  683. FUNCTION SetWUTime(WUTime: LONGINT): OSErr;
  684. FUNCTION GetWUTime(VAR WUTime: LONGINT; VAR WUFlag: SignedByte): OSErr;
  685. FUNCTION BatteryStatus(VAR Status: SignedByte; VAR Power: SignedByte): OSErr;
  686. FUNCTION ModemStatus(VAR Status: SignedByte): OSErr;
  687. FUNCTION IdleUpdate: LONGINT;
  688.     {$IFC NOT GENERATINGCFM}
  689.     INLINE $A285, $2E80;
  690.     {$ENDC}
  691. FUNCTION GetCPUSpeed: LONGINT;
  692.     {$IFC NOT GENERATINGCFM}
  693.     INLINE $70FF, $A485, $2E80;
  694.     {$ENDC}
  695. PROCEDURE EnableIdle;
  696.     {$IFC NOT GENERATINGCFM}
  697.     INLINE $7000, $A485;
  698.     {$ENDC}
  699. PROCEDURE DisableIdle;
  700.     {$IFC NOT GENERATINGCFM}
  701.     INLINE $7001, $A485;
  702.     {$ENDC}
  703. PROCEDURE SleepQInstall(qRecPtr: SleepQRecPtr);
  704.     {$IFC NOT GENERATINGCFM}
  705.     INLINE $205F, $A28A;
  706.     {$ENDC}
  707. PROCEDURE SleepQRemove(qRecPtr: SleepQRecPtr);
  708.     {$IFC NOT GENERATINGCFM}
  709.     INLINE $205F, $A48A;
  710.     {$ENDC}
  711. PROCEDURE AOn;
  712.     {$IFC NOT GENERATINGCFM}
  713.     INLINE $7004, $A685;
  714.     {$ENDC}
  715. PROCEDURE AOnIgnoreModem;
  716.     {$IFC NOT GENERATINGCFM}
  717.     INLINE $7005, $A685;
  718.     {$ENDC}
  719. PROCEDURE BOn;
  720.     {$IFC NOT GENERATINGCFM}
  721.     INLINE $7000, $A685;
  722.     {$ENDC}
  723. PROCEDURE AOff;
  724.     {$IFC NOT GENERATINGCFM}
  725.     INLINE $7084, $A685;
  726.     {$ENDC}
  727. PROCEDURE BOff;
  728.     {$IFC NOT GENERATINGCFM}
  729.     INLINE $7080, $A685;
  730.     {$ENDC}
  731. {  Public Power Management API (NEW!)  }
  732. FUNCTION PMSelectorCount: INTEGER;
  733.     {$IFC NOT GENERATINGCFM}
  734.     INLINE $7000, $A09E, $3E80;
  735.     {$ENDC}
  736. FUNCTION PMFeatures: LONGINT;
  737.     {$IFC NOT GENERATINGCFM}
  738.     INLINE $7001, $A09E, $2E80;
  739.     {$ENDC}
  740. FUNCTION GetSleepTimeout: ByteParameter;
  741.     {$IFC NOT GENERATINGCFM}
  742.     INLINE $7002, $A09E, $1E80;
  743.     {$ENDC}
  744. PROCEDURE SetSleepTimeout(timeout: ByteParameter);
  745.     {$IFC NOT GENERATINGCFM}
  746.     INLINE $101F, $4840, $303C, $0003, $A09E;
  747.     {$ENDC}
  748. FUNCTION GetHardDiskTimeout: ByteParameter;
  749.     {$IFC NOT GENERATINGCFM}
  750.     INLINE $7004, $A09E, $1E80;
  751.     {$ENDC}
  752. PROCEDURE SetHardDiskTimeout(timeout: ByteParameter);
  753.     {$IFC NOT GENERATINGCFM}
  754.     INLINE $101F, $4840, $303C, $0005, $A09E;
  755.     {$ENDC}
  756. FUNCTION HardDiskPowered: BOOLEAN;
  757.     {$IFC NOT GENERATINGCFM}
  758.     INLINE $7006, $A09E, $1E80;
  759.     {$ENDC}
  760. PROCEDURE SpinDownHardDisk;
  761.     {$IFC NOT GENERATINGCFM}
  762.     INLINE $7007, $A09E;
  763.     {$ENDC}
  764. FUNCTION IsSpindownDisabled: BOOLEAN;
  765.     {$IFC NOT GENERATINGCFM}
  766.     INLINE $7008, $A09E, $1E80;
  767.     {$ENDC}
  768. PROCEDURE SetSpindownDisable(setDisable: BOOLEAN);
  769.     {$IFC NOT GENERATINGCFM}
  770.     INLINE $101F, $4840, $303C, $0009, $A09E;
  771.     {$ENDC}
  772. FUNCTION HardDiskQInstall(VAR theElement: HDQueueElement): OSErr;
  773.     {$IFC NOT GENERATINGCFM}
  774.     INLINE $205F, $700A, $A09E, $3E80;
  775.     {$ENDC}
  776. FUNCTION HardDiskQRemove(VAR theElement: HDQueueElement): OSErr;
  777.     {$IFC NOT GENERATINGCFM}
  778.     INLINE $205F, $700B, $A09E, $3E80;
  779.     {$ENDC}
  780. PROCEDURE GetScaledBatteryInfo(whichBattery: INTEGER; VAR theInfo: BatteryInfo);
  781.     {$IFC NOT GENERATINGCFM}
  782.     INLINE $205F, $301F, $4840, $303C, $000C, $A09E, $2080;
  783.     {$ENDC}
  784. PROCEDURE AutoSleepControl(enableSleep: BOOLEAN);
  785.     {$IFC NOT GENERATINGCFM}
  786.     INLINE $101F, $4840, $303C, $000D, $A09E;
  787.     {$ENDC}
  788. FUNCTION GetIntModemInfo: LONGINT;
  789.     {$IFC NOT GENERATINGCFM}
  790.     INLINE $700E, $A09E, $2E80;
  791.     {$ENDC}
  792. PROCEDURE SetIntModemState(theState: INTEGER);
  793.     {$IFC NOT GENERATINGCFM}
  794.     INLINE $301F, $4840, $303C, $000F, $A09E;
  795.     {$ENDC}
  796. FUNCTION MaximumProcessorSpeed: INTEGER;
  797.     {$IFC NOT GENERATINGCFM}
  798.     INLINE $7010, $A09E, $3E80;
  799.     {$ENDC}
  800. FUNCTION CurrentProcessorSpeed: INTEGER;
  801.     {$IFC NOT GENERATINGCFM}
  802.     INLINE $7011, $A09E, $3E80;
  803.     {$ENDC}
  804. FUNCTION FullProcessorSpeed: BOOLEAN;
  805.     {$IFC NOT GENERATINGCFM}
  806.     INLINE $7012, $A09E, $1E80;
  807.     {$ENDC}
  808. FUNCTION SetProcessorSpeed(fullSpeed: BOOLEAN): BOOLEAN;
  809.     {$IFC NOT GENERATINGCFM}
  810.     INLINE $101F, $4840, $303C, $0013, $A09E, $1E80;
  811.     {$ENDC}
  812. FUNCTION GetSCSIDiskModeAddress: INTEGER;
  813.     {$IFC NOT GENERATINGCFM}
  814.     INLINE $7014, $A09E, $3E80;
  815.     {$ENDC}
  816. PROCEDURE SetSCSIDiskModeAddress(scsiAddress: INTEGER);
  817.     {$IFC NOT GENERATINGCFM}
  818.     INLINE $301F, $4840, $303C, $0015, $A09E;
  819.     {$ENDC}
  820. PROCEDURE GetWakeupTimer(VAR theTime: WakeupTime);
  821.     {$IFC NOT GENERATINGCFM}
  822.     INLINE $205F, $7016, $A09E;
  823.     {$ENDC}
  824. PROCEDURE SetWakeupTimer(VAR theTime: WakeupTime);
  825.     {$IFC NOT GENERATINGCFM}
  826.     INLINE $205F, $7017, $A09E;
  827.     {$ENDC}
  828. FUNCTION IsProcessorCyclingEnabled: BOOLEAN;
  829.     {$IFC NOT GENERATINGCFM}
  830.     INLINE $7018, $A09E, $1E80;
  831.     {$ENDC}
  832. PROCEDURE EnableProcessorCycling(enable: BOOLEAN);
  833.     {$IFC NOT GENERATINGCFM}
  834.     INLINE $101F, $4840, $303C, $0019, $A09E;
  835.     {$ENDC}
  836. FUNCTION BatteryCount: INTEGER;
  837.     {$IFC NOT GENERATINGCFM}
  838.     INLINE $701A, $A09E, $3E80;
  839.     {$ENDC}
  840. FUNCTION GetBatteryVoltage(whichBattery: INTEGER): Fixed;
  841.     {$IFC NOT GENERATINGCFM}
  842.     INLINE $301F, $4840, $303C, $001B, $A09E, $2E80;
  843.     {$ENDC}
  844. PROCEDURE GetBatteryTimes(whichBattery: INTEGER; VAR theTimes: BatteryTimeRec);
  845.     {$IFC NOT GENERATINGCFM}
  846.     INLINE $205F, $301F, $4840, $303C, $001C, $A09E;
  847.     {$ENDC}
  848. FUNCTION GetDimmingTimeout: ByteParameter;
  849.     {$IFC NOT GENERATINGCFM}
  850.     INLINE $701D, $A09E, $1E80;
  851.     {$ENDC}
  852. PROCEDURE SetDimmingTimeout(timeout: ByteParameter);
  853.     {$IFC NOT GENERATINGCFM}
  854.     INLINE $101F, $4840, $303C, $001E, $A09E;
  855.     {$ENDC}
  856. PROCEDURE DimmingControl(enableSleep: BOOLEAN);
  857.     {$IFC NOT GENERATINGCFM}
  858.     INLINE $101F, $4840, $303C, $001F, $A09E;
  859.     {$ENDC}
  860. FUNCTION IsDimmingControlDisabled: BOOLEAN;
  861.     {$IFC NOT GENERATINGCFM}
  862.     INLINE $7020, $A09E, $1E80;
  863.     {$ENDC}
  864. FUNCTION IsAutoSlpControlDisabled: BOOLEAN;
  865.     {$IFC NOT GENERATINGCFM}
  866.     INLINE $7021, $A09E, $1E80;
  867.     {$ENDC}
  868. FUNCTION PMgrStateQInstall(VAR theElement: PMgrQueueElement): OSErr;
  869.     {$IFC NOT GENERATINGCFM}
  870.     INLINE $205F, $7022, $A09E, $3E80;
  871.     {$ENDC}
  872. FUNCTION PMgrStateQRemove(VAR theElement: PMgrQueueElement): OSErr;
  873.     {$IFC NOT GENERATINGCFM}
  874.     INLINE $205F, $7023, $A09E, $3E80;
  875.     {$ENDC}
  876. FUNCTION UpdateSystemActivity(activity: ByteParameter): OSErr;
  877.     {$IFC NOT GENERATINGCFM}
  878.     INLINE $101F, $4840, $303C, $0024, $A09E, $3E80;
  879.     {$ENDC}
  880. FUNCTION DelaySystemIdle: OSErr;
  881.     {$IFC NOT GENERATINGCFM}
  882.     INLINE $7025, $A09E, $3E80;
  883.     {$ENDC}
  884. FUNCTION GetStartupTimer(VAR theTime: StartupTime): OSErr;
  885.     {$IFC NOT GENERATINGCFM}
  886.     INLINE $205F, $7026, $A09E, $3E80;
  887.     {$ENDC}
  888. FUNCTION SetStartupTimer(VAR theTime: StartupTime): OSErr;
  889.     {$IFC NOT GENERATINGCFM}
  890.     INLINE $205F, $7027, $A09E, $3E80;
  891.     {$ENDC}
  892. FUNCTION GetLastActivity(VAR theActivity: ActivityInfo): OSErr;
  893.     {$IFC NOT GENERATINGCFM}
  894.     INLINE $205F, $7028, $A09E, $3E80;
  895.     {$ENDC}
  896.  
  897. CONST
  898.     uppSleepQProcInfo = $00131832;
  899.     uppHDSpindownProcInfo = $000000C0;
  900.     uppPMgrStateChangeProcInfo = $000003C0;
  901.  
  902. FUNCTION NewSleepQProc(userRoutine: SleepQProcPtr): SleepQUPP;
  903.     {$IFC NOT GENERATINGCFM }
  904.     INLINE $2E9F;
  905.     {$ENDC}
  906.  
  907. FUNCTION NewHDSpindownProc(userRoutine: HDSpindownProcPtr): HDSpindownUPP;
  908.     {$IFC NOT GENERATINGCFM }
  909.     INLINE $2E9F;
  910.     {$ENDC}
  911.  
  912. FUNCTION NewPMgrStateChangeProc(userRoutine: PMgrStateChangeProcPtr): PMgrStateChangeUPP;
  913.     {$IFC NOT GENERATINGCFM }
  914.     INLINE $2E9F;
  915.     {$ENDC}
  916.  
  917. FUNCTION CallSleepQProc(message: LONGINT; qRecPtr: SleepQRecPtr; userRoutine: SleepQUPP): LONGINT;
  918.     {$IFC NOT GENERATINGCFM}
  919.     {To be implemented:  Glue to move parameters into registers.}
  920.     {$ENDC}
  921.  
  922. PROCEDURE CallHDSpindownProc(VAR theElement: HDQueueElement; userRoutine: HDSpindownUPP);
  923.     {$IFC NOT GENERATINGCFM}
  924.     INLINE $205F, $4E90;
  925.     {$ENDC}
  926.  
  927. PROCEDURE CallPMgrStateChangeProc(VAR theElement: PMgrQueueElement; stateBits: LONGINT; userRoutine: PMgrStateChangeUPP);
  928.     {$IFC NOT GENERATINGCFM}
  929.     INLINE $205F, $4E90;
  930.     {$ENDC}
  931. {$ENDC}
  932. {$ALIGN RESET}
  933. {$POP}
  934.  
  935. {$SETC UsingIncludes := PowerIncludes}
  936.  
  937. {$ENDC} {__POWER__}
  938.  
  939. {$IFC NOT UsingIncludes}
  940.  END.
  941. {$ENDC}
  942.